import java.util.ArrayList;
import java.util.Scanner;

public class C_0 
{
public static class Caracter
    {
              char c=' ';
              Integer pos;
              boolean noCero = false;
              
     public Caracter(char ca) 
         {
                      c = ca;
         }
    }

public static class Cadena
	{
		Caracter[] Caracters = new Caracter[0];
		int nLetras = 0;
		boolean next= true;

	public Cadena(int l, boolean n)
		{
			nLetras = l;
			next = n;
			Caracters = new Caracter[nLetras];
		}
	}
	 
	public static int ultimoIzq;
	
	public static int ultimoDerecha;
	
	public static int us;
	
	
     
	public static ArrayList <Cadena> operandos = new ArrayList <Cadena> ();

	public static ArrayList <Cadena> resultados = new ArrayList <Cadena> (); 



	public static Caracter[] alfabeto = new Caracter[30];//numero de caracteres del alfabeto 30 por si acaso

	public static Caracter[] usadas = new Caracter[10];

	public static Character[] ocupadas = new Character[11];



public static void main(String[] args)
{
	Scanner sc = new Scanner(System.in);
	while(sc.hasNext())
	{
		for(int i = 0; i < 30; i++)
		{
			alfabeto[i] = null;
		}
		for(int i = 0; i < 10; i++)
		{
			ocupadas[i] = null;
		}
		Scanner interno = new Scanner(sc.nextLine());
		ultimoIzq = 0;
		operandos.clear();
		while(true)
		{		
			String signo = operandos.size() == 0 ? "+" : interno.next();
			if(signo.equals("="))
			{
				break; 
			}
			String s = interno.next();
			Cadena actual = new Cadena(s.length(), signo.equals("+"));
			int i = s.length() - 1;
			for(char c : s.toCharArray())
			{
				if(alfabeto[c - 'A'] == null)
					alfabeto[c - 'A'] = new Caracter(c);
					actual.Caracters[i--] = alfabeto[c - 'A'];
			}
			if(s.length() > 1)
			{
				alfabeto[actual.Caracters[s.length() - 1].c - 'A'].noCero = true;
				ultimoIzq = Math.max(ultimoIzq, s.length());
				operandos.add(actual);
			}
		}
				resultados.clear();
				ultimoDerecha = 0;
		while(true)
		{
			if(!interno.hasNext())
				break;
			String signo = resultados.size() == 0 ? "+" : interno.next();
			String s = interno.next();
			Cadena actual = new Cadena(s.length(), signo.equals("+"));
			int i = s.length() - 1;
			for(char c : s.toCharArray())
			{
				if(alfabeto[c - 'A'] == null)
					alfabeto[c - 'A'] = new Caracter(c);
					actual.Caracters[i--] = alfabeto[c - 'A'];
			}
			if(s.length() > 1)
				alfabeto[actual.Caracters[s.length() - 1].c - 'A'].noCero = true;
				ultimoDerecha = Math.max(ultimoDerecha, s.length());
				resultados.add(actual);
		}
		us = 0;
		for(Caracter l : alfabeto)
		{
			if(l != null)
				usadas[us++] = l;
		}
		devolver(0, 0, 0, 0); // si retorna true entonces vuelve al while
		for(int i = 0; i < 10; i++)
			if(ocupadas[i] == null)
				System.out.print("*");
			else			
				System.out.print(ocupadas[i]);
				System.out.println();			
	}
}
        
public static boolean devolver(int columna, int Cadena, int iI, int iD)
{
	if(Cadena == operandos.size() + resultados.size())
	{
		int acumI = 0;
		int acumD = 0;
		for(Cadena p : operandos)
		{
			if(columna < p.nLetras)
			{
				if(p.next)
				{
					acumI += p.Caracters[columna].pos;
				}
				else
				{
					acumI -= p.Caracters[columna].pos;
				}
			}
		}
		acumI += iI;
		for(Cadena p : resultados)
		{
			if(columna < p.nLetras)
			{
				if(p.next)
				{
					acumD += p.Caracters[columna].pos;
				}
				else
				{
					acumD -= p.Caracters[columna].pos;
				}
			}
		}
		acumD += iD;
		int acumModI;
		int acumModD;
		if(acumI<0)
		{
			 acumModI = (((-acumI / 10) + 1) * 10) + acumI;
		}
		else
		{
			acumModI = acumI % 10;
		}
		if(acumD<0)
		{
			acumModD =((-acumD / 10) + 1) * 10 + acumD		;
			}
		else
		{
			acumModD = acumD % 10;
		}
		if(acumModI != acumModD)
			return false;
		if(acumI < 0)
			acumI -= 10;
		if(acumD < 0)
			acumD -= 10;
		return devolver(columna + 1, 0, acumI / 10, acumD / 10);
	}
	if(columna == Math.max(ultimoDerecha, ultimoIzq))
		return solve();
	Cadena actual = Cadena < operandos.size() ? operandos.get(Cadena) : resultados.get(Cadena - operandos.size());
	if(actual.nLetras <= columna || actual.Caracters[columna].pos != null)
		if(columna == actual.nLetras - 1 && actual.nLetras != 1 && actual.Caracters[columna].pos.intValue() == 0)
			return false;
		else
			return devolver(columna, Cadena + 1, iI, iD);
	for(int i = 0; i < 10; i++)
	{
		if(ocupadas[i] == null)
		{
			if(i == 0 && columna == actual.nLetras - 1 && actual.nLetras != 1)
				continue;
			ocupadas[i] = actual.Caracters[columna].c;
			actual.Caracters[columna].pos = i;
			if(devolver(columna, Cadena + 1, iI, iD))
				return true;
			actual.Caracters[columna].pos = null;
			ocupadas[i] = null;
		}
	}
	return false;
}

public static boolean solve()
{
	int totalI = 0;
	int totalD = 0;
	for(Cadena p : operandos)
	{
		int actual = 0;
		int potencia = 1;
		for(int i = 0; i < p.nLetras; i++)
		{
			actual += p.Caracters[i].pos * potencia;
			potencia *= 10;
		}
		if(p.next)
			totalI += actual;
		else
			totalI -= actual;
	}
	for(Cadena p : resultados)
	{
		int actual = 0;
		int potencia = 1;
		for(int i = 0; i < p.nLetras; i++)
		{
			actual += p.Caracters[i].pos * potencia;
			potencia *= 10;
		}
		if(p.next)
			totalD += actual;
		else
			totalD -= actual;
	}
	return totalD == totalI;
}
}